// // /​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​
// //  * 网盘客户端
// //  ​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​/

// #include "client.h"


// /* 发送协议命令（自动添加协议头）
//  * 参数：
//  *   ctx        - 客户端上下文
//  *   cmd        - 命令类型(来自protocol.h)
//  *   data       - 附加数据(如命令参数)
//  *   data_len   - 数据长度
//  * 工作流程：
//  *   1. 填充协议头结构
//  *   2. 发送协议头
//  *   3. 发送附加数据(如果有) */
// int send_command(ClientContext *ctx, Command cmd, const char *data, size_t data_len)
// {
//     protocol_header_t header = {
//         .magic = MAGIC_NUMBER, // 固定魔数
//         .command = cmd,
//         .data_length = data_len};

//     // 第一阶段：发送协议头
//     if (send(ctx->sockfd, &header, HEADER_LENGTH, 0) != 0)
//     {
//         fprintf(stderr, "[ERROR] Failed to send header\n");
//         return -1;
//     }

//     // 第二阶段：发送附加数据（如果有）
//     if (data_len > 0 && data != NULL)
//     {
//         if (send(ctx->sockfd, data, data_len, 0) != 0)
//         {
//             fprintf(stderr, "[ERROR] Failed to send payload\n");
//             return -2;
//         }
//     }
//     return 0;
// }

// /* 接收协议响应（自动解析协议头）
//  * 安全措施：
//  * 1. 缓冲区溢出检查
//  * 2. 魔数验证
//  * 3. 数据长度验证 */
// int receive_response(ClientContext *ctx, protocol_header_t *header,
//                      char *buf, size_t buf_size)
// {
//     // 第一阶段：接收固定长度协议头
//     if (recv(ctx->sockfd, header, HEADER_LENGTH, MSG_WAITALL) != HEADER_LENGTH)
//     {
//         fprintf(stderr, "[ERROR] Header receive failed\n");
//         return -1;
//     }

//     // 魔数验证（防止错误数据）
//     if (header->magic != MAGIC_NUMBER)
//     {
//         fprintf(stderr, "[ERROR] Invalid magic number: %X\n", header->magic);
//         return -2;
//     }

//     // 第二阶段：接收数据体（如果有）
//     if (header->data_length > 0)
//     {
//         // 防御：检查缓冲区是否足够
//         if (header->data_length > buf_size)
//         {
//             fprintf(stderr, "[ERROR] Buffer too small (%zu < %d)\n",
//                     buf_size, header->data_length);
//             return -3;
//         }
//         if (recv(ctx->sockfd, buf, header->data_length, MSG_WAITALL) != header->data_length)
//         {
//             fprintf(stderr, "[ERROR] Payload receive failed\n");
//             return -4;
//         }
//     }
//     return 0;
// }

// //  ​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​
// //  处理具体命令的响应
// //  每个处理函数只负责一种响应类型
// //  ​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​

// /* 处理LS命令响应（目录列表）
//  * 假设数据格式：
//  *   ID  Name    Size    Modified       Type
//  *   1   test.c  1024    2023-01-01     File */
// int handle_ls_response(ClientContext *ctx, const protocol_header_t *header,
//                        const char *data)
// {
//     // 显示当前目录（从上下文缓存中获取）
//     printf("当前目录: %s\n", ctx->current_dir);

//     // 表头格式化输出
//     printf("%-8s%-20s%-10s%-16s%s\n",
//            "ID", "Name", "Size", "Modified", "Type");

//     // 实际数据输出（这里简单打印，实际应解析结构化数据）
//     puts(data);
//     return 0;
// }

// /* 处理PWD命令响应（当前路径） */
// int handle_pwd_response(ClientContext *ctx, const protocol_header_t *header,
//                         const char *data)
// {
//     if (header->data_length > 0)
//     {
//         // 安全拷贝目录路径（防止溢出）
//         strncpy(ctx->current_dir, data, sizeof(ctx->current_dir) - 1);
//         ctx->current_dir[sizeof(ctx->current_dir) - 1] = '\0';

//         printf("当前目录: %s\n", ctx->current_dir);
//     }
//     return 0;
// }

// //  ​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​
// //  * 命令解析模块 - 将用户输入转换为结构化命令
// //  * 功能：
// //  * 1. 分离命令和参数
// //  * 2. 验证命令有效性
// //  * 3. 统一错误格式
// //  ​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​
// //  * 输入示例：
// //  *   "ls -l /tmp" -> cmd=CMD_LS_REQ, args="-l /tmp"
// //  *   "exit"       -> 返回1 */
// int parse_input(const char *input, ParsedCommand *out)
// {
//     // 验证输入的有效性
//     if(input == NULL || out == NULL){
//         return -1;
//     }
//     char cmd[16] = {0};
//     out->has_args = 0; // 默认无参数

//     // 安全分割命令和参数（防止缓冲区溢出）
//     if (sscanf(input, "%15s %255[^\n]", cmd, out->args) >= 1)
//     {
//         out->has_args = (strlen(out->args) > 0);
//     }

//     // 命令匹配（可扩展）
//     if (strcmp(cmd, "ls") == 0)
//         out->cmd = CMD_LS_REQ;
//     else if (strcmp(cmd, "cd") == 0)
//         out->cmd = CMD_CD_REQ;
//     else if (strcmp(cmd, "pwd") == 0)
//         out->cmd = CMD_PWD_REQ;
//     // ...其他命令...
//     else if (strcmp(cmd, "exit") == 0 || strcmp(cmd, "quit") == 0)
//         return 1; // 特殊返回码表示退出
//     else
//         return -1; // 未知命令

//     return 0;
// }

// //  ​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​
// //  * 主事件循环 - epoll驱动的状态机
// //  *   IDLE --发送命令--> AWAIT_RESP --收到响应--> IDLE
// //  ​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​
// int run_client_loop(ClientContext *ctx)
// {

//     int epllfd = epoll_create(1);
//     struct epoll_event event;
//     // 监控标准输入
//     event.events = EPOLLIN;
//     event.data.fd = STDIN_FILENO;
//     epoll_ctl(epllfd, EPOLL_CTL_ADD, STDIN_FILENO, &event);

//     // 监控套接字
//     event.events = EPOLLIN | EPOLLRDHUP;
//     event.data.fd = ctx->sockfd;
//     epoll_ctl(epllfd, EPOLL_CTL_ADD, ctx->sockfd, &event);

//     char input[MAX_BUF_SIZE];        // 输入
//     char response_buf[MAX_BUF_SIZE]; // 响应

//     printf("Client ready. Enter commands (help for usage):\n");

//     struct epoll_event readyset[1024];

//     while (1)
//     {
//         // 阻塞等待事件（无超时）
//         int readynum = epoll_wait(epllfd, readyset, 1024, -1);
//         // 处理所有就绪事件
//         for (int i = 0; i < readynum; i++)
//         {
//             /* 用户输入事件处理 */
//             if (readyset[i].data.fd == STDIN_FILENO)
//             {
//                 if (fgets(input, sizeof(input), stdin) == NULL)
//                     continue;

//                 // 去除换行符
//                 input[strcspn(input, "\n")] = '\0';

//                 // 解析用户输入
//                 ParsedCommand pc;
//                 int parse_ret = parse_input(input, &pc);

//                 // 退出命令处理
//                 if (parse_ret == 1)
//                 {
//                     printf("Goodbye!\n");
//                     return 0;
//                 }
//                 // 未知命令处理
//                 else if (parse_ret == -1)
//                 {
//                     printf("Unknown command. Type 'help' for usage.\n");
//                     continue;
//                 }

//                 // 发送命令到服务器
//                 if (send_command(ctx, pc.cmd, pc.has_args ? pc.args : NULL,
//                                  pc.has_args ? strlen(pc.args) : 0) != 0)
//                 {
//                     printf("Send command failed\n");
//                     ctx->state = STATE_ERROR;
//                 }
//                 else
//                 {
//                     ctx->state = STATE_AWAIT_RESP; // 状态转移
//                 }
//             }
//             /* 服务器响应事件处理 */
//             else if (readyset[i].data.fd == ctx->sockfd)
//             {
//                 protocol_header_t header;
//                 int ret = receive_response(ctx, &header, response_buf,
//                                            sizeof(response_buf));
//                 if (ret != 0)
//                 {
//                     printf("Receive error: %d\n", ret);
//                     ctx->state = STATE_ERROR;
//                     continue;
//                 }

//                 // 根据响应类型分发给不同处理函数
//                 switch (header.command)
//                 {
//                 case CMD_LS_RESP:
//                     handle_ls_response(ctx, &header, response_buf);
//                     break;
//                 case CMD_PWD_RESP:
//                     handle_pwd_response(ctx, &header, response_buf);
//                     break;
//                 // 其他命令响应...
//                 default:
//                     printf("Unknown response type: %d\n", header.command);
//                 }
//                 ctx->state = STATE_IDLE; // 状态转移
//             }
//         }
//     }
//     return 0;
// }

// //  ​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​
// //  * 初始化函数 - 建立连接并设置初始状态
// //  * 关键操作：
// //  * 1. 非阻塞connect
// //  * 2. 超时设置
// //  * 3. 初始状态配置
// //  ​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​
// int init_client(ClientContext *ctx, const char *ip, int port)
// {
//     // 创建非阻塞套接字
//     ctx->sockfd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);
//     if (ctx->sockfd < 0)
//     {
//         perror("socket");
//         return -1;
//     }

//     // 配置服务器地址
//     struct sockaddr_in addr;
//     addr.sin_family = AF_INET;
//     addr.sin_port = htons(port);
//     addr.sin_addr.s_addr = inet_addr(ip);

//     // 连接超时机制 todo

//     // 连接
//     connect(ctx->sockfd, (struct sockaddr *)&addr, sizeof(addr));
    
//     // 初始化状态
//     ctx->state = STATE_IDLE;
//     strcpy(ctx->current_dir, "/"); // 默认根目录
//     return 0;
// }

// // ​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​
// //  * 主函数 - 程序入口
// //  * 流程：
// //  * 1. 参数检查
// //  * 2. 初始化客户端
// //  * 3. 运行主循环
// //  * 4. 清理资源
// //  ​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​*​**​/
// int main(int argc, char *argv[])
// {
//     if (argc != 3)
//     {
//         printf("Usage: %s <IP> <PORT>\n", argv[0]);
//         return 1;
//     }

//     ClientContext ctx;
//     if (init_client(&ctx, argv[1], atoi(argv[2])) != 0)
//     {
//         printf("client connect error\n");
//         return 1;
//     }

//     int ret = run_client_loop(&ctx);
//     close(ctx.sockfd);
//     return ret;
// }